#include "threadpool2.h"
#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;

//ESRCH  No thread with the ID thread could be found.

vector<CTask *> CThreadPool::m_vecTaskList;
pthread_mutex_t CThreadPool::m_pthreadMutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t CThreadPool::m_pthreadCond =  PTHREAD_COND_INITIALIZER;
int	CThreadPool::Min_ThreadNum;
int	CThreadPool::Max_ThreadNum;
int CThreadPool::Max_TaskCounts;
int CThreadPool::Idle_ThreadNum;
int CThreadPool::Busy_ThreadNum;
int CThreadPool::Wait_ExitThreadNum;
bool CThreadPool::shutdown;
pthread_t * CThreadPool::pthread_id;

CThreadPool::CThreadPool(int min_thrednum, int max_thrednum, int max_tasknum)
{
	Min_ThreadNum = min_thrednum;
	Max_ThreadNum = max_thrednum;
	Max_TaskCounts = max_tasknum;
	Idle_ThreadNum = min_thrednum;
	Busy_ThreadNum = 0;
	Wait_ExitThreadNum = 0;
	shutdown = false;

	CreatePool();
}

void *CThreadPool::Thread_WorkerFunc(void *args)
{
	CTask *stakTemp;

	while(1)
	{
		pthread_mutex_lock(&m_pthreadMutex);

		while((m_vecTaskList.size()) == 0 && (!shutdown))
		{
			cout << "等待的线程的id为：" << pthread_self() << endl;
			pthread_cond_wait(&m_pthreadCond, &m_pthreadMutex);

			if(Wait_ExitThreadNum > 0)
			{
				Wait_ExitThreadNum --;

				if(Idle_ThreadNum > Min_ThreadNum)
				{
					Idle_ThreadNum --;
					cout << "多余将要退出的线程id为：" << pthread_self() << endl;
					pthread_mutex_unlock(&m_pthreadMutex);
					pthread_exit(NULL);
				}
			}
		}

		if(shutdown)
		{
			pthread_mutex_unlock(&m_pthreadMutex);
			cout << "退出的线程ID为：" << pthread_self() << endl;
			pthread_exit(NULL);
		}

		vector<CTask *>::iterator iter = m_vecTaskList.begin();
		if(iter != m_vecTaskList.end())
		{
			stakTemp = *iter;
			m_vecTaskList.erase(iter);
		}

		Busy_ThreadNum ++;
		pthread_mutex_unlock(&m_pthreadMutex);
		stakTemp->run();

		pthread_mutex_lock(&m_pthreadMutex);
		Busy_ThreadNum --;
		pthread_mutex_unlock(&m_pthreadMutex);
	}

	pthread_exit(NULL);
}

void *CThreadPool::Thread_ManagerFunc(void *args)
{
	CThreadPool pool;
	while(!shutdown)
	{
		cout << "我是管理线程" << endl;
	//	sleep(PTHREAD_MANAGER_SLEEP); 执行过快如果此时sleep将看不到效果
		cout << "111111111111111111" << endl;
		int tasksize = pool.getTaskSize();
		pthread_mutex_lock(&m_pthreadMutex);
		int alive = Idle_ThreadNum;
		cout << "33333333333333333" << endl;
		int busy = Busy_ThreadNum;
		pthread_mutex_unlock(&m_pthreadMutex);
		cout << "2222222222222222222222222222222222222222222222" << endl;
		if(tasksize >= MIN_WAIT_TASK_COUNTS && Idle_ThreadNum < Max_ThreadNum)
		{
			cout << "添加" << endl;
			pthread_mutex_lock(&m_pthreadMutex);

			int add_threadnum = 0;
			for(int i = 0; i < Max_ThreadNum && add_threadnum < DEFAULT_ADD_THREAD_COUNTS; i ++)
			{
				if(pthread_id[i] == 0 || !pool.ThreadAlive(pthread_id[i]))
				{
					pthread_create(&pthread_id[i], NULL, Thread_WorkerFunc, NULL);
					add_threadnum ++;
					Idle_ThreadNum ++;

					cout << "将要新添加的新城的id为：" << pthread_id[i] << endl;
				}
			}

			pthread_mutex_unlock(&m_pthreadMutex);
		}

		if(alive >= busy * 2 && alive > Min_ThreadNum)
		{
			cout << "删除" << endl;
			pthread_mutex_lock(&m_pthreadMutex);
			Wait_ExitThreadNum = DEFAULT_DEL_THREAD_COUNTS;
			pthread_mutex_unlock(&m_pthreadMutex);
			for(int i = 0; i < DEFAULT_DEL_THREAD_COUNTS; i ++)
			{
				pthread_cond_signal(&m_pthreadCond);
			}
		}

		cout << "在工作" << endl;
	}

	pthread_exit(NULL);
}


int CThreadPool::CreatePool()
{
	pthread_id = new pthread_t [Max_ThreadNum];
	memset(pthread_id, 0, sizeof(pthread_id));

    for(int i = 0; i < this->Idle_ThreadNum; ++ i)
    {
        pthread_create(&pthread_id[i], NULL, CThreadPool::Thread_WorkerFunc, NULL);
    }

	pthread_create(&ManagerThreadId, NULL, Thread_ManagerFunc, NULL);

	return 0;
}
int CThreadPool::AddTask(CTask *task)
{
	pthread_mutex_lock(&m_pthreadMutex);
	m_vecTaskList.push_back(task);
	cout << "add a task succe" << endl;
	pthread_mutex_unlock(&m_pthreadMutex);
	pthread_cond_signal(&m_pthreadCond);

	return 0;
}
bool CThreadPool::ThreadAlive(pthread_t tid)
{
	int kill_rc = pthread_kill(tid, 0);
	if(kill_rc == ESRCH) //活着
		return false;

	return true;         //死亡
}
int CThreadPool::StopAll()
{
	if(shutdown)
	{
		cout << "不可重复关闭" << endl;
		return -1;
	}

	pthread_mutex_lock(&m_pthreadMutex);
	shutdown = true;
	pthread_cond_broadcast(&m_pthreadCond);
	pthread_mutex_unlock(&m_pthreadMutex);

	for(int i = 0; i < Idle_ThreadNum; ++i)
	{
		pthread_join(pthread_id[i], NULL);
	}

	delete []pthread_id;
	pthread_id = NULL;
	pthread_mutex_destroy(&m_pthreadMutex);
	pthread_cond_destroy(&m_pthreadCond);

	return 0;
}
int CThreadPool::getTaskSize()
{
	pthread_mutex_lock(&m_pthreadMutex);
	int counts = m_vecTaskList.size();
	pthread_mutex_unlock(&m_pthreadMutex);

	return counts;
}

int main (void)
{
    cout << "begin............." << endl;
    CThreadPool pool(3, 100, 100);


    for(int i = 0; i < 200; ++ i)
    {
        CTask *task = new CTask();
        pool.AddTask(task);
    }
    while(pool.getTaskSize() != 0)
    {
        cout << pool.getTaskSize() << endl;
        continue;
    }

    pool.StopAll();
    cout << "end..............." << endl;
    return 0;
}
